package protect.week11;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

/**
 * @author thinkpad - 83start
 * @version v1.0
 * @create 2022/11/16 9:23
 * @package protect.week11
 * @description 2068. 检查两个字符串是否几乎相等
 * 如果两个字符串 word1 和 word2 中从 'a' 到 'z' 每一个字母出现频率之差都 不超过 3 ，那么我们称这两个字符串 word1 和 word2 几乎相等 。
 *
 * 给你两个长度都为 n 的字符串 word1 和 word2 ，如果 word1 和 word2 几乎相等 ，请你返回 true ，否则返回 false 。
 *
 * 一个字母 x 的出现 频率 指的是它在字符串中出现的次数。
 *
 *  
 *
 * 示例 1：
 *
 * 输入：word1 = "aaaa", word2 = "bccb"
 * 输出：false
 * 解释：字符串 "aaaa" 中有 4 个 'a' ，但是 "bccb" 中有 0 个 'a' 。
 * 两者之差为 4 ，大于上限 3 。
 * 示例 2：
 *
 * 输入：word1 = "abcdeef", word2 = "abaaacc"
 * 输出：true
 * 解释：word1 和 word2 中每个字母出现频率之差至多为 3 ：
 * - 'a' 在 word1 中出现了 1 次，在 word2 中出现了 4 次，差为 3 。
 * - 'b' 在 word1 中出现了 1 次，在 word2 中出现了 1 次，差为 0 。
 * - 'c' 在 word1 中出现了 1 次，在 word2 中出现了 2 次，差为 1 。
 * - 'd' 在 word1 中出现了 1 次，在 word2 中出现了 0 次，差为 1 。
 * - 'e' 在 word1 中出现了 2 次，在 word2 中出现了 0 次，差为 2 。
 * - 'f' 在 word1 中出现了 1 次，在 word2 中出现了 0 次，差为 1 。
 * 示例 3：
 *
 * 输入：word1 = "cccddabba", word2 = "babababab"
 * 输出：true
 * 解释：word1 和 word2 中每个字母出现频率之差至多为 3 ：
 * - 'a' 在 word1 中出现了 2 次，在 word2 中出现了 4 次，差为 2 。
 * - 'b' 在 word1 中出现了 2 次，在 word2 中出现了 5 次，差为 3 。
 * - 'c' 在 word1 中出现了 3 次，在 word2 中出现了 0 次，差为 3 。
 * - 'd' 在 word1 中出现了 2 次，在 word2 中出现了 0 次，差为 2 。
 *
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode.cn/problems/check-whether-two-strings-are-almost-equivalent
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
 */

public class Ch02_CheckAlmostEquivalent {
    public boolean checkAlmostEquivalent(String word1, String word2) {
        // 获取两个单词中字母出现的次数
        HashMap<Character, Integer> word1Map = countWord(word1);
        HashMap<Character, Integer> word2Map = countWord(word2);


        Set<Character> mapSet1 = word1Map.keySet();
        Iterator<Character> iterator1 = mapSet1.iterator();
        while (iterator1.hasNext()){
            // 遍历两个hashmap
            Character tmp = iterator1.next();
            if (!word2Map.containsKey(tmp)){
                if (word1Map.get(tmp) > 3){
                    return false;
                }
            }else {
                if (Math.abs(word1Map.get(tmp) - word2Map.get(tmp)) > 3){
                    return false;
                }
            }
        }

        Set<Character> mapSet2 = word2Map.keySet();
        Iterator<Character> iterator2 = mapSet2.iterator();
        while (iterator2.hasNext()){
            // 遍历两个hashmap
            Character tmp = iterator2.next();
            if (!word1Map.containsKey(tmp)){
                if (word2Map.get(tmp) > 3){
                    return false;
                }
            }else {
                if (Math.abs(word1Map.get(tmp) - word2Map.get(tmp)) > 3){
                    return false;
                }
            }
        }

        return true;
    }

    public HashMap<Character,Integer> countWord(String word){
        HashMap<Character,Integer> wordMap = new HashMap<>();
        for (int i = 0; i < word.length(); i++) {
            char tmp = word.charAt(i);
            if (wordMap.containsKey(tmp)){
                wordMap.replace(tmp,wordMap.get(tmp) + 1);
            }else {
                wordMap.put(tmp,1);
            }
        }

        return wordMap;
    }



    public static void main(String[] args) {
        Ch02_CheckAlmostEquivalent ch02_checkAlmostEquivalent = new Ch02_CheckAlmostEquivalent();
        System.out.println(ch02_checkAlmostEquivalent.checkAlmostEquivalent("java", "python"));
    }
}
